// sgu270
// 题意：
// 现在有n(<=100)个杯子，初始第一个杯子里面有球，现在有m(<=1000)条交换，
// 每条交换就是交换某两个不相同的杯子，每条交换使用一次，交换顺序不一定。
// 现在问最后球可能在哪些杯子里。
//
// 题解：
// 拿交换规则构图，得道一个有重边的无向图，初始球在1号点。
// 然后就是分类讨论了。
//
// 观察可以知道，不与1号点直接相邻但是与之联通的点是肯定可以到达的。
// 接下来就是要判断1号点本身以及与之直接相邻的点的可达性。
//
// 我们先考虑与1号点直接相邻的点，如果某个相邻点和1号点之间边的数目为奇数，
// 那肯定可以达到，如果是偶数，那么可以是这几种情况：
//   1. 首先有其他相邻点的边数超过1，那么可以通过那个点过渡，把当前点
//      与1相邻的边变成奇数；
//   2. 如果1号点能经过别的点到当前点，那么也是可以达到当前点的;
//   3. 如果1号点到当前点之后，当前点有路径可以绕回当前点，那么也行。
//
// 考虑1号点本身也是很类似，
//   1. 首先就是如果有相邻的偶数边的情况，可达；
//   2. 如果可以绕一圈回来也可达；
//   3. 如果有两个相邻边数大于1的情况也可达。
//   4. 还有一种比较极端的情况就是1周围没有相邻点，就留在1了。
//
// ml:run = $bin < input
// ml:opt = 0
// ml:ccf += -g
#include <iostream>
#include <cstring>

int const maxn = 200;
int map[maxn][maxn];
bool neighbor[maxn];
bool can[maxn];
bool vis[maxn];
int n, m;

void dfs(int x)
{
    vis[x] = true;
    if (!neighbor[x]) can[x] = true;
    for (int i = 1; i <= n; i++) {
        if (!map[x][i] || vis[i]) continue;
        dfs(i);
    }
}

bool dfs(int x, int t)
{
    vis[x] = true;
    if (x == t) return true;
    for (int i = 1; i <= n; i++) {
        if (!map[x][i] || vis[i]) continue;
        if (x == 1 && i == t) continue;
        if (dfs(i, t)) return true;
    }
    return false;
}

bool can_back(int x)
{
    for (int i = 1; i <= n; i++) {
        if (!map[x][i] || vis[i]) continue;
        if (map[x][i] >= 2) return true;
    }
    return false;
}

bool single_back(int x, int s, int c = 0)
{
    vis[x] = true;
    for (int i = 1; i <= n; i++) {
        if (!map[x][i] || (i != s && vis[i])) continue;
        if (x == s && i == s) continue;
        if (x != s && i == s && c > 1) return true;
        if (i != s)
            if (single_back(i, s, c + 1)) return true;
    }
    return false;
}

bool go_neighbor(int x)
{
    vis[x] = true;
    for (int i = 2; i <= n; i++) {
        if (!map[x][i] || vis[i]) continue;
        if (neighbor[i]) return true;
        if (go_neighbor(i)) return true;
    }
    return false;
}

void check()
{
    int count = 0;
    for (int i = 2; i <= n; i++)
        if (map[1][i] >= 2) count++;
    if (count >= 2) { can[1] = true; return; }
    for (int i = 2; i <= n; i++)
        if (map[1][i] && !(map[1][i] & 1)) { can[1] = true; return; }
    count = 0;
    for (int i = 2; i <= n; i++)
        if (map[1][i]) count++;
    if (!count) { can[1] = true; return; }

    for (int i = 2; i <= n; i++) {
        if (!neighbor[i]) continue;
        std::memset(vis, 0, sizeof(vis));
        vis[1] = true;
        if (go_neighbor(i)) { can[1] = true; return; }
    }
    for (int i = 2; i <= n; i++) {
        if (!neighbor[i]) continue;
        if (!((map[i][1] & 1) && map[i][1] > 1)) continue;
        std::memset(vis, 0, sizeof(vis));
        vis[1] = true;
        if (can_back(i)) { can[1] = true; return; }
        if (single_back(i, i)) { can[1] = true; return; }
    }
}

void dfs_neighbor(int x, int s)
{
    vis[x] = true;
    if (x != s && neighbor[x]) can[s] = can[x] = true;
    for (int i = 2; i <= n; i++) {
        if (i == 1 || vis[i]) continue;
        dfs_neighbor(i, s);
    }
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int x, y; std::cin >> x >> y;
        map[x][y]++;
        map[y][x]++;
    }
    for (int i = 1; i <= n; i++)
        neighbor[i] = map[1][i];
    neighbor[1] = true;
    dfs(1);
    int has_even = 0;
    for (int i = 2; i <= n; i++)
        if (map[1][i] >= 2) has_even++;

    /* for (int i = 2; i <= n; i++) { */
    /*     if (!neighbor[i]) continue; */
    /*     std::memset(vis, 0, sizeof(vis)); */
    /*     dfs_neighbor(i, i); */
    /* } */

    for (int i = 2; i <= n; i++) {
        if (!neighbor[i] || can[i]) continue;
        if (map[1][i] & 1) { can[i] = true; continue; }
        if (has_even > 1) { can[i] = true; continue; }

        std::memset(vis, 0, sizeof(vis));
        if (dfs(1, i)) { can[i] = true; continue; }

        std::memset(vis, 0, sizeof(vis));
        vis[1] = true;
        if (can_back(i)) { can[i] = true; continue; }
        if (single_back(i, i)) { can[i] = true; continue; }

        std::memset(vis, 0, sizeof(vis));
        vis[i] = true;
        if (can_back(1)) can[i] = true;
        if (single_back(1, 1)) { can[i] = true; continue; }
    }
    check();
    for (int i = 1; i <= n; i++)
        if (can[i]) std::cout << i << " ";
}

